package com.moon.cloud.common.utils;

import com.moon.cloud.common.exception.MoonException;

import java.util.Collection;
import java.util.Map;

/**
 * 断言工具类
 * 断言失败时抛出 MoonException
 */
public class AssertUtils {

    /**
     * 断言表达式为 true
     */
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言表达式为 true（自定义错误码）
     */
    public static void isTrue(boolean expression, int errorCode, String message) {
        if (!expression) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言表达式为 false
     */
    public static void isFalse(boolean expression, String message) {
        if (expression) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言表达式为 false（自定义错误码）
     */
    public static void isFalse(boolean expression, int errorCode, String message) {
        if (expression) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言对象不为 null
     */
    public static void notNull(Object object, String message) {
        if (object == null) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言对象不为 null（自定义错误码）
     */
    public static void notNull(Object object, int errorCode, String message) {
        if (object == null) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言对象为 null
     */
    public static void isNull(Object object, String message) {
        if (object != null) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言对象为 null（自定义错误码）
     */
    public static void isNull(Object object, int errorCode, String message) {
        if (object != null) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言字符串不为空
     */
    public static void notEmpty(String text, String message) {
        if (StringUtils.isEmpty(text)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言字符串不为空（自定义错误码）
     */
    public static void notEmpty(String text, int errorCode, String message) {
        if (StringUtils.isEmpty(text)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言字符串不为空白
     */
    public static void notBlank(String text, String message) {
        if (StringUtils.isBlank(text)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言字符串不为空白（自定义错误码）
     */
    public static void notBlank(String text, int errorCode, String message) {
        if (StringUtils.isBlank(text)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言集合不为空
     */
    public static void notEmpty(Collection<?> collection, String message) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言集合不为空（自定义错误码）
     */
    public static void notEmpty(Collection<?> collection, int errorCode, String message) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言 Map 不为空
     */
    public static void notEmpty(Map<?, ?> map, String message) {
        if (CollectionUtils.isEmpty(map)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言 Map 不为空（自定义错误码）
     */
    public static void notEmpty(Map<?, ?> map, int errorCode, String message) {
        if (CollectionUtils.isEmpty(map)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言数组不为空
     */
    public static void notEmpty(Object[] array, String message) {
        if (CollectionUtils.isEmpty(array)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言数组不为空（自定义错误码）
     */
    public static void notEmpty(Object[] array, int errorCode, String message) {
        if (CollectionUtils.isEmpty(array)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言两个对象相等
     */
    public static void equals(Object obj1, Object obj2, String message) {
        if (obj1 == null || !obj1.equals(obj2)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言两个对象相等（自定义错误码）
     */
    public static void equals(Object obj1, Object obj2, int errorCode, String message) {
        if (obj1 == null || !obj1.equals(obj2)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言两个对象不相等
     */
    public static void notEquals(Object obj1, Object obj2, String message) {
        if (obj1 != null && obj1.equals(obj2)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言两个对象不相等（自定义错误码）
     */
    public static void notEquals(Object obj1, Object obj2, int errorCode, String message) {
        if (obj1 != null && obj1.equals(obj2)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言字符串长度在范围内
     */
    public static void lengthBetween(String text, int min, int max, String message) {
        if (text == null || text.length() < min || text.length() > max) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言字符串长度在范围内（自定义错误码）
     */
    public static void lengthBetween(String text, int min, int max, int errorCode, String message) {
        if (text == null || text.length() < min || text.length() > max) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言数值在范围内
     */
    public static void between(Integer value, int min, int max, String message) {
        if (value == null || value < min || value > max) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言数值在范围内（自定义错误码）
     */
    public static void between(Integer value, int min, int max, int errorCode, String message) {
        if (value == null || value < min || value > max) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言数值在范围内（Long）
     */
    public static void between(Long value, long min, long max, String message) {
        if (value == null || value < min || value > max) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言数值在范围内（Long，自定义错误码）
     */
    public static void between(Long value, long min, long max, int errorCode, String message) {
        if (value == null || value < min || value > max) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言为正数
     */
    public static void positive(Integer value, String message) {
        if (value == null || value <= 0) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言为正数（自定义错误码）
     */
    public static void positive(Integer value, int errorCode, String message) {
        if (value == null || value <= 0) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言为正数（Long）
     */
    public static void positive(Long value, String message) {
        if (value == null || value <= 0) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言为正数（Long，自定义错误码）
     */
    public static void positive(Long value, int errorCode, String message) {
        if (value == null || value <= 0) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言为非负数
     */
    public static void nonNegative(Integer value, String message) {
        if (value == null || value < 0) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言为非负数（自定义错误码）
     */
    public static void nonNegative(Integer value, int errorCode, String message) {
        if (value == null || value < 0) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言为非负数（Long）
     */
    public static void nonNegative(Long value, String message) {
        if (value == null || value < 0) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言为非负数（Long，自定义错误码）
     */
    public static void nonNegative(Long value, int errorCode, String message) {
        if (value == null || value < 0) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言手机号格式正确
     */
    public static void isMobile(String mobile, String message) {
        if (!ValidateUtils.isMobile(mobile)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言手机号格式正确（自定义错误码）
     */
    public static void isMobile(String mobile, int errorCode, String message) {
        if (!ValidateUtils.isMobile(mobile)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言邮箱格式正确
     */
    public static void isEmail(String email, String message) {
        if (!ValidateUtils.isEmail(email)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言邮箱格式正确（自定义错误码）
     */
    public static void isEmail(String email, int errorCode, String message) {
        if (!ValidateUtils.isEmail(email)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 断言身份证号格式正确
     */
    public static void isIdCard(String idCard, String message) {
        if (!ValidateUtils.isIdCard(idCard)) {
            throw new MoonException(400, message);
        }
    }

    /**
     * 断言身份证号格式正确（自定义错误码）
     */
    public static void isIdCard(String idCard, int errorCode, String message) {
        if (!ValidateUtils.isIdCard(idCard)) {
            throw new MoonException(errorCode, message);
        }
    }

    /**
     * 直接抛出异常
     */
    public static void fail(String message) {
        throw new MoonException(500, message);
    }

    /**
     * 直接抛出异常（自定义错误码）
     */
    public static void fail(int errorCode, String message) {
        throw new MoonException(errorCode, message);
    }
}
